{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct\n",
    "import matplotlib.pyplot as plt\n",
    "struct.pack('>i',2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "import struct\n",
    "# 拿到数据\n",
    "with open('./train-images-idx3-ubyte','rb') as f:\n",
    "    # 在读出4个int\n",
    "    buffer = f.read(4*4)\n",
    "    head = struct.unpack('>iiii',buffer)\n",
    "    print(head)\n",
    "    length = head[1] * head[2] * head[3]\n",
    "    print(length)\n",
    "    buffer = f.read(length)\n",
    "    data = struct.unpack('>{}b'.format(length),buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看data长度\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看data类型\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把data规划为三维矩阵\n",
    "import numpy as np\n",
    "imgs = np.reshape(data,(head[1],head[2],head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看形状\n",
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 查看五张图片\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\feature_extraction\\image.py:167: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int):\n",
      "d:\\python\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3,and in 3.9 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    }
   ],
   "source": [
    "# 加载数据\n",
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 赋值\n",
    "X, y = mnist['data'],mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把X变成二位\n",
    "some_digit = X[36000]\n",
    "some_digit_image = some_digit.reshape(28,28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定位36000的数字为5\n",
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,X_test,y_train,y_test = X[:60000],X[60000:],y[:60000],y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14366, 21199, 53085, ...,  4158, 27016, 13146])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 讲数据集交叉验证 使每个数据分布平均\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,y_train = X_train[shuffle_index],y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5 确定他是或者不是\n",
    "# 定义数值\n",
    "y_train_5 = (y_train ==5 )\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False,  True, False],\n",
       "       [False,  True, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [ True,  True, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5 = (y_test ==5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:35: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:597: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:836: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, fit_path=True,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:862: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, positive=False):\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:1074: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=1, eps=np.finfo(np.float).eps,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:1306: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  max_n_alphas=1000, n_jobs=1, eps=np.finfo(np.float).eps,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\least_angle.py:1442: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, copy_X=True, positive=False):\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\randomized_l1.py:152: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  precompute=False, eps=np.finfo(np.float).eps,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\randomized_l1.py:318: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=np.finfo(np.float).eps, random_state=None,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\randomized_l1.py:575: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  eps=4 * np.finfo(np.float).eps, n_jobs=1,\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD分类器.\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42)\n",
    "sgd_clf.fit(X_train,y_train_5)\n",
    "\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.95685, 0.96155, 0.96485])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难\n",
    "\n",
    "# 3个折叠 正确在95%以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classsifier(BaseEstimator):\n",
    "    def fit(self,X,y = None):\n",
    "        pass\n",
    "    def predict(self,X):\n",
    "        return np.zeros((len(X),1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X),1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90905, 0.91055, 0.90935])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5Classsifier()\n",
    "cross_val_score(never_5_clf,X_train,y_train_5,cv = 3,scoring = 'accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 比如10个图片里面有9张是5还有一张不是五，所以才会这么高\n",
    "* 这说明这个准确率不具有代表性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器最好的是混淆矩阵\n",
    "# 想知道分类器把3和5混淆了多少次，可以通过混淆矩阵来知道\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "y_train_pred = cross_val_predict(sgd_clf,X_train,y_train_5,cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## corss_val_score 相比\n",
    "     * 同样它们是交叉验证\n",
    "     * 返回的不是评估分数 是每个折叠的预测\n",
    "     * 没一个实例模型在预测时使用的数据在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53349,  1230],\n",
       "       [ 1105,  4316]], dtype=int64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5,y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7782185358817165"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "precision_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7961630695443646"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 检查一张图的时候准确度只有82%的几率为正确的 有69%的几率检测出数字5\n",
    "# 精度和召回合成单一指标为f1\n",
    "# 只有召回和精度分数都高的时候才会获得f1分数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7870885383422996"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度 召回率的权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 如何设置阈值\n",
    "# # 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression为例\n",
    "# from sklearn.linear_model import LogisticRegression\n",
    "# clf = LogisticRegression()  \n",
    "# clf.fit(X_train,y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:,1]  \n",
    "# threshold = 0.75\n",
    "# pred_label = pred_proba > threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-48405.46755713])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阈值可以降低召回率 \n",
    "threshold = 20000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 返回决策之 而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf,X_train,y_train_5,cv = 3,method = 'decision_function')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores 就可以计算阈值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplptlib 绘制精度和召回的阈值\n",
    "def plot_precision_recall_vs_threshold(precisions,recalls,thresholds):\n",
    "    plt.plot(thresholds,precisions[:-1],'b--',label = 'precision',linewidth = 2)\n",
    "    plt.plot(thresholds,recalls[:-1],'g-',label = 'Recall',linewidth = 2)\n",
    "    plt.xlabel('Threshold',fontsize = 16)\n",
    "    plt.legend(loc = 'upper left',fontsize = 16)\n",
    "    plt.ylim([0,1])\n",
    "    \n",
    "plt.figure(figsize = (8,4))\n",
    "plot_precision_recall_vs_threshold(precisions,recalls,thresholds)\n",
    "plt.xlim([-700000,700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions,recalls):\n",
    "    plt.plot(recalls,precisions,'b-',linewidth = 2)\n",
    "    plt.xlabel('召回',fontsize = 16)\n",
    "    plt.ylabel('精度',fontsize = 16)\n",
    "    plt.axis([0,1,0,1])\n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "plot_precision_vs_recall(precisions,recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90% 阈值大概在30000\n",
    "y_train_pred_90 = (y_scores > 30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.820502512562814"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7529976019184652"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 真的真类率，和假的真类率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "fpr,tpr,thresholds = roc_curve(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr,tpr,label = None):\n",
    "    plt.plot(fpr,tpr,linewidth=2,label=label)\n",
    "    plt.plot([0,1],[0,1],'k--')\n",
    "    plt.axis([0,1,0,1])\n",
    "    plt.xlabel('假真类率',fontsize = 16)\n",
    "    plt.ylabel('真正类率',fontsize = 16)\n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "plot_roc_curve(fpr,tpr)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9631166619161449"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下的面积\n",
    "from sklearn.metrics import roc_auc_score\n",
    "roc_auc_score(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器 比较SGD分类器 ROC曲线和ROC AUC分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\gradient_boosting.py:34: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  from ._gradient_boosting import predict_stages\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\gradient_boosting.py:34: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  from ._gradient_boosting import predict_stages\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators = 10,random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_clf,X_train,y_train_5,cv=3,method = 'predict_proba')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [0.8, 0.2],\n",
       "       ...,\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ],\n",
       "       [1. , 0. ]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线 需要的是分数不是概率\n",
    "y_scores_forest = y_probas_forest[:,1]\n",
    "fpr_forest,tpr_forest,thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0. , 0.2, ..., 0. , 0. , 0. ])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (8,6))\n",
    "plt.plot(fpr,tpr,'b:',linewidth=2,label='SGD')\n",
    "plot_roc_curve(fpr_forest,tpr_forest,'Random Forest')\n",
    "plt.legend(loc = 'lower right',fontsize = 16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.993339988423875"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好\n",
    "roc_auc_score(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9847925266130785"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 精度和召回也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf,X_train,y_train_5,cv=3)\n",
    "precision_score(y_train_5,y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8361925843940232"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    " ### 优势\n",
    "        * OVO 要用到部分训练集数据，在对这部分数据进行区分为2个类别进行训练\n",
    "        * 对于比较小的集合OVO比较的有又小 大的集合OVA速度更快，所以一般OVA更常用\n",
    "        * sklearn检查到使用二元分类算法的时候会自动运行OVA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train,y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-175518.44409171, -334333.72171755, -386095.10772141,\n",
       "        -204525.25073547, -329355.18741554,  -48405.46755713,\n",
       "        -838964.63752714, -363747.76616074, -568109.99823634,\n",
       "        -804490.80692697]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 训练10个二元分类器 获得图片决策分数 然后选择分数最高的\n",
    "# 返回10个书，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别会存储在classes_这个属性中 按大小排列\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.classes_[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\multiclass.py:417: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_binary = np.empty(y.shape, np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\base.py:326: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  indices = (scores > 0).astype(np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  使用OVO策略 实现一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter = 5,tol= -np.infty,random_state = 42))\n",
    "ovo_clf.fit(X_train,y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\forest.py:482: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_store_unique_indices = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\tree\\tree.py:149: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  y_encoded = np.zeros(y.shape, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train,y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\ensemble\\base.py:157: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  dtype=np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0. , 0. , 0. , 0.1, 0. , 0.8, 0. , 0. , 0.1, 0. ]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.87717457, 0.85984299, 0.87613142])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_val_score(sgd_clf,X_train,y_train,cv= 3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90841832, 0.91094555, 0.90963645])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 这样准确率能达到90%以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf,X_train_scaled,y_train,cv=3,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:618: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_folds = np.zeros(n_samples, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:428: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  fold_sizes = (n_samples // n_splits) * np.ones(n_splits, dtype=np.int)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\model_selection\\_split.py:108: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_mask = np.zeros(_num_samples(X), dtype=np.bool)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5734,    2,   25,   10,   11,   48,   42,    9,   39,    3],\n",
       "       [   2, 6461,   52,   29,    6,   39,    6,   12,  122,   13],\n",
       "       [  56,   32, 5350,   91,   83,   21,   92,   53,  163,   17],\n",
       "       [  47,   37,  139, 5357,    1,  219,   35,   61,  143,   92],\n",
       "       [  19,   29,   37,   10, 5396,    7,   50,   30,   66,  198],\n",
       "       [  77,   38,   38,  194,   77, 4589,  116,   28,  168,   96],\n",
       "       [  32,   19,   50,    3,   53,   80, 5627,    6,   48,    0],\n",
       "       [  26,   21,   75,   29,   55,   11,    4, 5790,   17,  237],\n",
       "       [  57,  142,   65,  153,   15,  151,   63,   26, 5032,  147],\n",
       "       [  41,   35,   25,   85,  188,   31,    3,  221,   76, 5244]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf,X_train_scaled,y_train,cv=3)\n",
    "conf_mx = confusion_matrix(y_train,y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow来绘制矩阵\n",
    "plt.matshow(conf_mx,cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 却出错误率\n",
    "row_sums = conf_mx.sum(axis = 1,keepdims = True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 填充对角线 只保留错误\n",
    "np.fill_diagonal(norm_conf_mx,0)\n",
    "plt.matshow(norm_conf_mx,cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 优化分类器\n",
    "    * 收集更多数据\n",
    "    * 开发新特征\n",
    "    * 优化分类算法\n",
    "    * 使用pollow或者opencv对图片处理\n",
    "    * 单个分析错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances,images_per_row=10,**options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances),images_per_row)\n",
    "    images = [instance.reshape(size,size)for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size,size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis =1))\n",
    "    image = np.concatenate(row_images,axis = 0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis('off')\n",
    "    \n",
    "# 查看数字3和5\n",
    "cl_a,cl_b =3,5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "\n",
    "plt.figure(figsize = (8,8))\n",
    "plt.subplot(221);\n",
    "plot_digits(X_aa[:25],images_per_row=5)\n",
    "plt.subplot(222);\n",
    "plot_digits(X_ab[:25],images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25],images_per_row=5)\n",
    "plt.subplot(224);\n",
    "plot_digits(X_bb[:25],images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\neighbors\\base.py:781: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  self._y = np.empty(y.shape, dtype=np.int)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "y_train_large = (y_train >=7)\n",
    "y_train_odd = (y_train % 2 ==1)\n",
    "y_multilabel = np.c_[y_train_large,y_train_odd]\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train,y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类 不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # 评估分类器的发放很多 方法之一就是测量每个标签的F1分数\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf,X_train,y_multilabel,cv =3 )\n",
    "# f1_score(y_multilabel,y_train_knn_pred,average = 'macro')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声 目标图片还原为原始图片  创建训练集和测试集\n",
    "noise =np.random.randint(0,100,(len(X_train),784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0,100,(len(X_test),784))\n",
    "X_test_mod = X_test +noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28,28),cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28,28),cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\sklearn\\neighbors\\base.py:781: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  self._y = np.empty(y.shape, dtype=np.int)\n"
     ]
    }
   ],
   "source": [
    "knn_clf.fit(X_train_mod,y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28,28),cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
